// 在文件顶部添加直接控制台日志
console.log('======== WhatsApp Platform Backend 启动 ========');
console.log('当前工作目录:', process.cwd());
console.log('当前环境:', process.env.NODE_ENV);
console.log('代理设置:', process.env.PROXY_SERVER || '未设置（使用系统代理）');

const express = require('express');
const http = require('http');
const cors = require('cors');
const helmet = require('helmet');
const rateLimit = require('express-rate-limit');
const config = require('./config');
const { connectDB } = require('./config/mongodb');
const { initializeWhatsApp } = require('./services/whatsappService');
const socketService = require('./services/socketService');
const filterService = require('./services/filterService');
const cleanupService = require('./services/cleanupService');
const logger = require('./utils/logger');
const healthCheck = require('./utils/healthCheck');
const routes = require('./routes');
const models = require('./models');

// 创建Express应用
const app = express();
const server = http.createServer(app);

// 允许的域名列表
const allowedOrigins = config.frontendURLs || ['http://localhost:3000'];

// CORS配置
const corsOptions = {
  origin: function (origin, callback) {
    // 允许没有origin的请求（如Postman或移动端）
    if (!origin || allowedOrigins.indexOf(origin) !== -1) {
      callback(null, true);
    } else {
      logger.security('CORS拒绝', { origin });
      callback(new Error('CORS策略不允许此来源访问'));
    }
  },
  methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
  allowedHeaders: ['Content-Type', 'Authorization', 'X-Requested-With', 'x-request-id', 'cache-control'],
  credentials: true,
  maxAge: 86400 // 24小时
};

// 速率限制中间件
const apiLimiter = rateLimit({
  windowMs: config.security?.rateLimitWindow || 15 * 60 * 1000, // 默认15分钟
  max: config.security?.rateLimitMax || 100, // 默认100次
  standardHeaders: true,
  legacyHeaders: false,
  message: {
    status: 429,
    message: '请求过多，请稍后再试。'
  }
});

// 中间件
app.use(cors(corsOptions));
app.use(helmet({
  contentSecurityPolicy: {
    directives: {
      defaultSrc: ["'self'"],
      connectSrc: ["'self'", ...allowedOrigins],
      frameSrc: ["'self'"],
      imgSrc: ["'self'", 'data:'],
    }
  }
}));
app.use(express.json({ limit: '2mb' })); // 限制请求体大小
app.use(express.urlencoded({ extended: true, limit: '2mb' }));
app.use('/api', apiLimiter); // 对API路由应用速率限制

// 初始化Socket.IO
const io = socketService.setup(server);

// 注册数据库模型到应用
app.set('models', models);
app.set('db', models); // 添加兼容模式，以支持req.app.get('db')调用

// 初始化服务
const initializeServices = async () => {
  const services = [
    { 
      name: 'MongoDB', 
      initFn: connectDB,
      critical: false, // MongoDB非关键，可以降级为SQLite
      fallback: () => {
        logger.warn('MongoDB连接失败，使用SQLite作为备用存储');
        return true;
      }
    },
    { 
      name: 'WhatsApp', 
      initFn: () => initializeWhatsApp('default'),
      critical: false, // WhatsApp服务可以后续手动连接
      fallback: () => {
        logger.warn('WhatsApp服务初始化失败，请稍后手动连接');
        return true;
      }
    },
    { 
      name: '内容过滤', 
      initFn: filterService.initialize,
      critical: false,
      fallback: () => {
        logger.warn('内容过滤服务初始化失败，将使用基础过滤功能');
        return true;
      }
    },
    { 
      name: '资源清理', 
      initFn: cleanupService.initialize,
      critical: false,
      fallback: () => {
        logger.warn('资源清理服务初始化失败，请手动清理资源');
        return true;
      }
    }
  ];
  
  const serviceStatus = {
    successful: [],
    failed: [],
    degraded: []
  };
  
  // 依次初始化所有服务
  for (const service of services) {
    try {
      logger.info(`正在初始化${service.name}服务...`);
      const result = await service.initFn();
      
      if (result === false) {
        // 服务初始化返回false，尝试降级
        if (service.fallback) {
          await service.fallback();
          serviceStatus.degraded.push(service.name);
          logger.info(`${service.name}服务已降级运行`);
        } else {
          serviceStatus.failed.push(service.name);
          logger.error(`${service.name}服务初始化失败`);
        }
      } else {
        serviceStatus.successful.push(service.name);
      logger.info(`${service.name}服务初始化成功`);
      }
    } catch (error) {
      logger.error(`${service.name}服务初始化失败:`, error);
      
      // 如果是关键服务且无法降级，则停止启动
      if (service.critical) {
        logger.error(`关键服务${service.name}初始化失败，无法启动应用`);
        throw new Error(`关键服务${service.name}初始化失败`);
      }
      
      // 非关键服务尝试降级
      if (service.fallback) {
        try {
          await service.fallback();
          serviceStatus.degraded.push(service.name);
          logger.info(`${service.name}服务已降级运行`);
        } catch (fallbackError) {
          serviceStatus.failed.push(service.name);
          logger.error(`${service.name}服务降级失败:`, fallbackError);
        }
      } else {
        serviceStatus.failed.push(service.name);
      }
    }
  }
  
  // 记录服务初始化状态
  logger.info('服务初始化完成:', {
    成功: serviceStatus.successful,
    降级: serviceStatus.degraded,
    失败: serviceStatus.failed
  });
  
  // 如果有服务失败或降级，设置健康检查状态
  if (serviceStatus.failed.length > 0 || serviceStatus.degraded.length > 0) {
    app.locals.serviceStatus = serviceStatus;
  }
  
  return true;
};

// 初始化健康检查
healthCheck.initialize(app);

// 路由
app.use('/api', routes);

// 404处理
app.use((req, res) => {
  logger.debug(`未找到资源: ${req.method} ${req.path}`);
  res.status(404).json({ message: '请求的资源不存在' });
});

// 错误处理
app.use((err, req, res, next) => {
  const statusCode = err.statusCode || 500;
  
  // 记录错误，包含请求详情
  logger.error({
    message: '服务器错误',
    error: err.message,
    stack: err.stack,
    path: req.path,
    method: req.method,
    query: req.query,
    ip: req.ip
  });
  
  // 只在生产环境隐藏详细错误信息
  let errorResponse = {
    message: statusCode === 500 ? '服务器内部错误' : err.message
  };
  
  if (config.nodeEnv !== 'production') {
    errorResponse.stack = err.stack;
    errorResponse.details = err.details || null;
  }
  
  res.status(statusCode).json(errorResponse);
});

// 优雅关闭处理
const gracefulShutdown = async () => {
  logger.info('应用正在关闭...');
  
  try {
    // 停止清理服务
    cleanupService.shutdown();
    
    // 关闭Socket.IO连接
    socketService.close();
    
    // 关闭服务器
    if (server.listening) {
      await new Promise((resolve) => {
        server.close(resolve);
      });
      logger.info('HTTP服务器已关闭');
    }
    
    // 关闭数据库连接
    // TODO: 实现数据库连接关闭
    
    logger.info('应用已安全关闭');
  } catch (error) {
    logger.error('关闭应用时出错:', error);
  }
  
  process.exit(0);
};

// 信号处理
process.on('SIGTERM', gracefulShutdown);
process.on('SIGINT', gracefulShutdown);

// 进程错误处理
process.on('unhandledRejection', (reason, promise) => {
  console.error('未处理的Promise拒绝:', reason);
  console.error('详细堆栈:', reason.stack);
  logger.error({
    message: '未处理的Promise拒绝:',
    error: reason.message,
    stack: reason.stack
  });
});

process.on('uncaughtException', (error) => {
  console.error('未捕获的异常:', error);
  console.error('详细堆栈:', error.stack);
  logger.error({
    message: '未捕获的异常:',
    error: error.message,
    stack: error.stack
  });
  
  // 尝试优雅地关闭服务器
  if (server.listening) {
    logger.info('尝试优雅地关闭服务器...');
    server.close(() => {
      logger.info('服务器已安全关闭');
      process.exit(1);
    });
    
    // 如果关闭服务器花费太长时间，强制退出
    setTimeout(() => {
      logger.error('无法优雅地关闭服务器，强制退出');
      process.exit(1);
    }, 10000);
  } else {
    logger.info('服务器未启动，直接退出');
    process.exit(1);
  }
});

// 启动服务器
const PORT = process.env.PORT || config.port || 3001;
server.listen(PORT, async () => {
  logger.info(`服务器运行在端口 ${PORT}, 环境: ${config.nodeEnv || 'development'}`);
  
  try {
    // 初始化各项服务
    await initializeServices();
    
    // 显示启动信息
    logger.info('===================================');
    logger.info(`WhatsApp平台后端服务已启动`);
    logger.info(`访问地址: http://localhost:${PORT}`);
    logger.info(`API文档: http://localhost:${PORT}/api/docs`);
    logger.info(`健康检查: http://localhost:${PORT}/api/health`);
    logger.info('===================================');
  } catch (err) {
    logger.error('服务初始化过程中发生致命错误:', err);
    
    // 给予一定时间让日志写入，然后退出
    setTimeout(() => {
      process.exit(1);
    }, 1000);
  }
});

// 导出app用于测试
module.exports = { app, server }; 